home *** CD-ROM | disk | FTP | other *** search
/ PC World 2008 March / PCWorld_2008-03_cd.bin / v cisle / mobiDVD / MobiDVD-1.0.0.6.exe / xulrunner / components / nsHandlerService.js < prev    next >
Text File  |  2007-07-25  |  19KB  |  523 lines
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  3.  *
  4.  * The contents of this file are subject to the Mozilla Public License Version
  5.  * 1.1 (the "License"); you may not use this file except in compliance with
  6.  * the License. You may obtain a copy of the License at
  7.  * http://www.mozilla.org/MPL/
  8.  *
  9.  * Software distributed under the License is distributed on an "AS IS" basis,
  10.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11.  * for the specific language governing rights and limitations under the
  12.  * License.
  13.  *
  14.  * The Original Code is the Mozilla browser.
  15.  *
  16.  * The Initial Developer of the Original Code is Mozilla.
  17.  * Portions created by the Initial Developer are Copyright (C) 2007
  18.  * the Initial Developer. All Rights Reserved.
  19.  *
  20.  * Contributor(s):
  21.  *   Myk Melez <myk@mozilla.org>
  22.  *
  23.  * Alternatively, the contents of this file may be used under the terms of
  24.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  25.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  26.  * in which case the provisions of the GPL or the LGPL are applicable instead
  27.  * of those above. If you wish to allow use of your version of this file only
  28.  * under the terms of either the GPL or the LGPL, and not to allow others to
  29.  * use your version of this file under the terms of the MPL, indicate your
  30.  * decision by deleting the provisions above and replace them with the notice
  31.  * and other provisions required by the GPL or the LGPL. If you do not delete
  32.  * the provisions above, a recipient may use your version of this file under
  33.  * the terms of any one of the MPL, the GPL or the LGPL.
  34.  *
  35.  * ***** END LICENSE BLOCK ***** */
  36.  
  37. const Ci = Components.interfaces;
  38. const Cc = Components.classes;
  39. const Cu = Components.utils;
  40. const Cr = Components.results;
  41.  
  42.  
  43. // namespace prefix
  44. const NC_NS                 = "http://home.netscape.com/NC-rdf#";
  45.  
  46. // type list properties
  47.  
  48. const NC_MIME_TYPES         = NC_NS + "MIME-types";
  49. const NC_PROTOCOL_SCHEMES   = NC_NS + "Protocol-Schemes";
  50.  
  51. // content type ("type") properties
  52.  
  53. const NC_EDITABLE           = NC_NS + "editable";
  54.  
  55. // nsIMIMEInfo::MIMEType
  56. const NC_VALUE              = NC_NS + "value";
  57.  
  58. // references nsIHandlerInfo record
  59. const NC_HANDLER_INFO       = NC_NS + "handlerProp";
  60.  
  61. // handler info ("info") properties
  62.  
  63. // nsIHandlerInfo::preferredAction
  64. const NC_SAVE_TO_DISK       = NC_NS + "saveToDisk";
  65. const NC_HANDLE_INTERNALLY  = NC_NS + "handleInternal";
  66. const NC_USE_SYSTEM_DEFAULT = NC_NS + "useSystemDefault";
  67.  
  68. // nsIHandlerInfo::alwaysAskBeforeHandling
  69. const NC_ALWAYS_ASK         = NC_NS + "alwaysAsk";
  70.  
  71. // references nsIHandlerApp record
  72. const NC_PREFERRED_APP      = NC_NS + "externalApplication";
  73.  
  74. // handler app ("handler") properties
  75.  
  76. // nsIHandlerApp::name
  77. const NC_PRETTY_NAME        = NC_NS + "prettyName";
  78.  
  79. // nsILocalHandlerApp::executable
  80. const NC_PATH               = NC_NS + "path";
  81.  
  82. // nsIWebHandlerApp::uriTemplate
  83. const NC_URI_TEMPLATE       = NC_NS + "uriTemplate";
  84.  
  85.  
  86. Cu.import("resource://gre/modules/XPCOMUtils.jsm");
  87.  
  88.  
  89. function HandlerService() {}
  90.  
  91. HandlerService.prototype = {
  92.   //**************************************************************************//
  93.   // XPCOM Plumbing
  94.  
  95.   classDescription: "Handler Service",
  96.   classID:          Components.ID("{32314cc8-22f7-4f7f-a645-1a45453ba6a6}"),
  97.   contractID:       "@mozilla.org/uriloader/handler-service;1",
  98.   QueryInterface:   XPCOMUtils.generateQI([Ci.nsIHandlerService]),
  99.  
  100.  
  101.   //**************************************************************************//
  102.   // nsIHandlerService
  103.  
  104.   store: function HS_store(aHandlerInfo) {
  105.     // FIXME: when we switch from RDF to something with transactions (like
  106.     // SQLite), enclose the following changes in a transaction so they all
  107.     // get rolled back if any of them fail and we don't leave the datastore
  108.     // in an inconsistent state.
  109.  
  110.     this._ensureRecordsForType(aHandlerInfo);
  111.     this._storePreferredAction(aHandlerInfo);
  112.     this._storePreferredHandler(aHandlerInfo);
  113.     this._storeAlwaysAsk(aHandlerInfo);
  114.   },
  115.  
  116.  
  117.   //**************************************************************************//
  118.   // Storage Methods
  119.  
  120.   _storePreferredAction: function HS__storePreferredAction(aHandlerInfo) {
  121.     var infoID = this._getInfoID(aHandlerInfo);
  122.  
  123.     switch(aHandlerInfo.preferredAction) {
  124.       case Ci.nsIHandlerInfo.saveToDisk:
  125.         this._setLiteral(infoID, NC_SAVE_TO_DISK, "true");
  126.         this._removeValue(infoID, NC_HANDLE_INTERNALLY);
  127.         this._removeValue(infoID, NC_USE_SYSTEM_DEFAULT);
  128.         break;
  129.  
  130.       case Ci.nsIHandlerInfo.handleInternally:
  131.         this._setLiteral(infoID, NC_HANDLE_INTERNALLY, "true");
  132.         this._removeValue(infoID, NC_SAVE_TO_DISK);
  133.         this._removeValue(infoID, NC_USE_SYSTEM_DEFAULT);
  134.         break;
  135.  
  136.       case Ci.nsIHandlerInfo.useSystemDefault:
  137.         this._setLiteral(infoID, NC_USE_SYSTEM_DEFAULT, "true");
  138.         this._removeValue(infoID, NC_SAVE_TO_DISK);
  139.         this._removeValue(infoID, NC_HANDLE_INTERNALLY);
  140.         break;
  141.  
  142.       // This value is indicated in the datastore either by the absence of
  143.       // the three properties or by setting them all "false".  Of these two
  144.       // options, the former seems preferable, because it reduces the size
  145.       // of the RDF file and thus the amount of stuff we have to parse.
  146.       case Ci.nsIHandlerInfo.useHelperApp:
  147.       default:
  148.         this._removeValue(infoID, NC_SAVE_TO_DISK);
  149.         this._removeValue(infoID, NC_HANDLE_INTERNALLY);
  150.         this._removeValue(infoID, NC_USE_SYSTEM_DEFAULT);
  151.         break;
  152.     }
  153.   },
  154.  
  155.   _storePreferredHandler: function HS__storePreferredHandler(aHandlerInfo) {
  156.     var infoID = this._getInfoID(aHandlerInfo);
  157.     var handlerID = this._getPreferredHandlerID(aHandlerInfo);
  158.     var handler = aHandlerInfo.preferredApplicationHandler;
  159.  
  160.     if (handler) {
  161.       // First add a record for the preferred app to the datasource.  In the
  162.       // process we also need to remove any vestiges of an existing record, so
  163.       // we remove any properties that we aren't overwriting.
  164.       this._setLiteral(handlerID, NC_PRETTY_NAME, handler.name);
  165.       if (handler instanceof Ci.nsILocalHandlerApp) {
  166.         this._setLiteral(handlerID, NC_PATH, handler.executable.path);
  167.         this._removeValue(handlerID, NC_URI_TEMPLATE);
  168.       }
  169.       else {
  170.         handler.QueryInterface(Ci.nsIWebHandlerApp);
  171.         this._setLiteral(handlerID, NC_URI_TEMPLATE, handler.uriTemplate);
  172.         this._removeValue(handlerID, NC_PATH);
  173.       }
  174.  
  175.       // Finally, make this app be the preferred app for the handler info.
  176.       // Note: at least some code completely ignores this setting and assumes
  177.       // the preferred app is the one whose URI follows the appropriate pattern.
  178.       this._setResource(infoID, NC_PREFERRED_APP, handlerID);
  179.     }
  180.     else {
  181.       // There isn't a preferred handler.  Remove the existing record for it,
  182.       // if any.
  183.       this._removeValue(handlerID, NC_PRETTY_NAME);
  184.       this._removeValue(handlerID, NC_PATH);
  185.       this._removeValue(handlerID, NC_URI_TEMPLATE);
  186.       this._removeValue(infoID, NC_PREFERRED_APP);
  187.     }
  188.   },
  189.  
  190.   _storeAlwaysAsk: function HS__storeAlwaysAsk(aHandlerInfo) {
  191.     var infoID = this._getInfoID(aHandlerInfo);
  192.     this._setLiteral(infoID,
  193.                      NC_ALWAYS_ASK,
  194.                      aHandlerInfo.alwaysAskBeforeHandling ? "true" : "false");
  195.   },
  196.  
  197.  
  198.   //**************************************************************************//
  199.   // Storage Utils
  200.  
  201.   // RDF Service
  202.   __rdf: null,
  203.   get _rdf() {
  204.     if (!this.__rdf)
  205.       this.__rdf = Cc["@mozilla.org/rdf/rdf-service;1"].
  206.                    getService(Ci.nsIRDFService);
  207.     return this.__rdf;
  208.   },
  209.  
  210.   // RDF Container Utils
  211.   __containerUtils: null,
  212.   get _containerUtils() {
  213.     if (!this.__containerUtils)
  214.       this.__containerUtils = Cc["@mozilla.org/rdf/container-utils;1"].
  215.                               getService(Ci.nsIRDFContainerUtils);
  216.     return this.__containerUtils;
  217.   },
  218.  
  219.   // RDF datasource containing content handling config (i.e. mimeTypes.rdf)
  220.   __ds: null,
  221.   get _ds() {
  222.     if (!this.__ds) {
  223.       var fileLocator = Cc["@mozilla.org/file/directory_service;1"].
  224.                         getService(Ci.nsIProperties);
  225.       var file = fileLocator.get("UMimTyp", Ci.nsIFile);
  226.       // FIXME: make this a memoizing getter if we use it anywhere else.
  227.       var ioService = Cc["@mozilla.org/network/io-service;1"].
  228.                       getService(Ci.nsIIOService);
  229.       var fileHandler = ioService.getProtocolHandler("file").
  230.                         QueryInterface(Ci.nsIFileProtocolHandler);
  231.       this.__ds =
  232.         this._rdf.GetDataSourceBlocking(fileHandler.getURLSpecFromFile(file));
  233.     }
  234.  
  235.     return this.__ds;
  236.   },
  237.  
  238.   /**
  239.    * Get the string identifying whether this is a MIME or a protocol handler.
  240.    * This string is used in the URI IDs of various RDF properties.
  241.    * 
  242.    * @param aHandlerInfo {nsIHandlerInfo} the handler for which to get the class
  243.    * 
  244.    * @returns {string} the ID
  245.    */
  246.   _getClass: function HS__getClass(aHandlerInfo) {
  247.     if (aHandlerInfo instanceof Ci.nsIMIMEInfo)
  248.       return "mimetype";
  249.     else
  250.       return "scheme";
  251.   },
  252.  
  253.   /**
  254.    * Return the unique identifier for a content type record, which stores
  255.    * the editable and value fields plus a reference to the type's handler.
  256.    * 
  257.    * |urn:(mimetype|scheme):<type>|
  258.    * 
  259.    * XXX: should this be a property of nsIHandlerInfo?
  260.    * 
  261.    * @param aHandlerInfo {nsIHandlerInfo} the type for which to get the ID
  262.    * 
  263.    * @returns {string} the ID
  264.    */
  265.   _getTypeID: function HS__getTypeID(aHandlerInfo) {
  266.     return "urn:" + this._getClass(aHandlerInfo) + ":" + aHandlerInfo.type;
  267.   },
  268.  
  269.   /**
  270.    * Return the unique identifier for a type info record, which stores
  271.    * the preferredAction and alwaysAsk fields plus a reference to the preferred
  272.    * handler.  Roughly equivalent to the nsIHandlerInfo interface.
  273.    * 
  274.    * |urn:(mimetype|scheme):handler:<type>|
  275.    * 
  276.    * FIXME: the type info record should be merged into the type record,
  277.    * since there's a one to one relationship between them, and this record
  278.    * merely stores additional attributes of a content type.
  279.    * 
  280.    * @param aHandlerInfo {nsIHandlerInfo} the handler for which to get the ID
  281.    * 
  282.    * @returns {string} the ID
  283.    */
  284.   _getInfoID: function HS__getInfoID(aHandlerInfo) {
  285.     return "urn:" + this._getClass(aHandlerInfo) + ":handler:" +
  286.            aHandlerInfo.type;
  287.   },
  288.  
  289.   /**
  290.    * Return the unique identifier for a preferred handler record, which stores
  291.    * information about the preferred handler for a given content type, including
  292.    * its human-readable name and the path to its executable (for a local app)
  293.    * or its URI template (for a web app).
  294.    * 
  295.    * |urn:(mimetype|scheme):externalApplication:<type>|
  296.    *
  297.    * XXX: should this be a property of nsIHandlerApp?
  298.    *
  299.    * FIXME: this should be an arbitrary ID, and we should retrieve it from
  300.    * the datastore for a given content type via the NC:ExternalApplication
  301.    * property rather than looking for a specific ID, so a handler doesn't
  302.    * have to change IDs when it goes from being a possible handler to being
  303.    * the preferred one (once we support possible handlers).
  304.    * 
  305.    * @param aHandlerInfo {nsIHandlerInfo} the handler for which to get the ID
  306.    * 
  307.    * @returns {string} the ID
  308.    */
  309.   _getPreferredHandlerID: function HS__getPreferredHandlerID(aHandlerInfo) {
  310.     return "urn:" + this._getClass(aHandlerInfo) + ":externalApplication:" +
  311.            aHandlerInfo.type;
  312.   },
  313.  
  314.   /**
  315.    * Get the list of types for the given class, creating the list if it
  316.    * doesn't already exist.  The class can be either "mimetype" or "scheme"
  317.    * (i.e. the result of a call to _getClass).
  318.    * 
  319.    * |urn:(mimetype|scheme)s|
  320.    * |urn:(mimetype|scheme)s:root|
  321.    * 
  322.    * @param aClass {string} the class for which to retrieve a list of types
  323.    *
  324.    * @returns {nsIRDFContainer} the list of types
  325.    */
  326.   _ensureAndGetTypeList: function HS__ensureAndGetTypeList(aClass) {
  327.     // FIXME: once nsIHandlerInfo supports retrieving the scheme
  328.     // (and differentiating between MIME and protocol content types),
  329.     // implement support for protocols.
  330.  
  331.     var source = this._rdf.GetResource("urn:" + aClass + "s");
  332.     var property =
  333.       this._rdf.GetResource(aClass == "mimetype" ? NC_MIME_TYPES
  334.                                                  : NC_PROTOCOL_SCHEMES);
  335.     var target = this._rdf.GetResource("urn:" + aClass + "s:root");
  336.  
  337.     // Make sure we have an arc from the source to the target.
  338.     if (!this._ds.HasAssertion(source, property, target, true))
  339.       this._ds.Assert(source, property, target, true);
  340.  
  341.     // Make sure the target is a container.
  342.     if (!this._containerUtils.IsContainer(this._ds, target))
  343.       this._containerUtils.MakeSeq(this._ds, target);
  344.  
  345.     // Get the type list as an RDF container.
  346.     var typeList = Cc["@mozilla.org/rdf/container;1"].
  347.                    createInstance(Ci.nsIRDFContainer);
  348.     typeList.Init(this._ds, target);
  349.  
  350.     return typeList;
  351.   },
  352.  
  353.   /**
  354.    * Make sure there are records in the datasource for the given content type
  355.    * by creating them if they don't already exist.  We have to do this before
  356.    * storing any specific data, because we can't assume the presence
  357.    * of the records (the nsIHandlerInfo object might have been created
  358.    * from the OS), and the records have to all be there in order for the helper
  359.    * app service to properly construct an nsIHandlerInfo object for the type.
  360.    *
  361.    * Based on old downloadactions.js::_ensureMIMERegistryEntry.
  362.    *
  363.    * @param aHandlerInfo {nsIHandlerInfo} the type to make sure has a record
  364.    */
  365.   _ensureRecordsForType: function HS__ensureRecordsForType(aHandlerInfo) {
  366.     // Get the list of types.
  367.     var typeList = this._ensureAndGetTypeList(this._getClass(aHandlerInfo));
  368.  
  369.     // If there's already a record in the datastore for this type, then we
  370.     // don't need to do anything more.
  371.     var typeID = this._getTypeID(aHandlerInfo);
  372.     var type = this._rdf.GetResource(typeID);
  373.     if (typeList.IndexOf(type) != -1)
  374.       return;
  375.  
  376.     // Create a basic type record for this type.
  377.     typeList.AppendElement(type);
  378.     this._setLiteral(typeID, NC_EDITABLE, "true");
  379.     this._setLiteral(typeID, NC_VALUE, aHandlerInfo.type);
  380.     
  381.     // Create a basic info record for this type.
  382.     var infoID = this._getInfoID(aHandlerInfo);
  383.     this._setLiteral(infoID, NC_ALWAYS_ASK, "false");
  384.     this._setResource(typeID, NC_HANDLER_INFO, infoID);
  385.     // XXX Shouldn't we set preferredAction to useSystemDefault?
  386.     // That's what it is if there's no record in the datastore; why should it
  387.     // change to useHelperApp just because we add a record to the datastore?
  388.     
  389.     // Create a basic preferred handler record for this type.
  390.     // XXX Not sure this is necessary, since preferred handlers are optional,
  391.     // and nsExternalHelperAppService::FillHandlerInfoForTypeFromDS doesn't seem
  392.     // to require the record , but downloadactions.js::_ensureMIMERegistryEntry
  393.     // used to create it, so we'll do the same.
  394.     var preferredHandlerID = this._getPreferredHandlerID(aHandlerInfo);
  395.     this._setLiteral(preferredHandlerID, NC_PATH, "");
  396.     this._setResource(infoID, NC_PREFERRED_APP, preferredHandlerID);
  397.   },
  398.  
  399.   /**
  400.    * Set a property of an RDF source to a literal value.
  401.    *
  402.    * @param sourceURI   {string} the URI of the source
  403.    * @param propertyURI {string} the URI of the property
  404.    * @param value       {string} the literal value
  405.    */
  406.   _setLiteral: function HS__setLiteral(sourceURI, propertyURI, value) {
  407.     var source = this._rdf.GetResource(sourceURI);
  408.     var property = this._rdf.GetResource(propertyURI);
  409.     var target = this._rdf.GetLiteral(value);
  410.     
  411.     this._setTarget(source, property, target);
  412.   },
  413.  
  414.   /**
  415.    * Set a property of an RDF source to a resource.
  416.    *
  417.    * @param sourceURI   {string} the URI of the source
  418.    * @param propertyURI {string} the URI of the property
  419.    * @param resourceURI {string} the URI of the resource
  420.    */
  421.   _setResource: function HS__setResource(sourceURI, propertyURI, resourceURI) {
  422.     var source = this._rdf.GetResource(sourceURI);
  423.     var property = this._rdf.GetResource(propertyURI);
  424.     var target = this._rdf.GetResource(resourceURI);
  425.     
  426.     this._setTarget(source, property, target);
  427.   },
  428.  
  429.   /**
  430.    * Assert an arc into the RDF datasource if there is no arc with the given
  431.    * source and property; otherwise, if there is already an existing arc,
  432.    * change it to point to the given target.
  433.    *
  434.    * @param source    {nsIRDFResource}  the source
  435.    * @param property  {nsIRDFResource}  the property
  436.    * @param value     {nsIRDFNode}      the target
  437.    */
  438.   _setTarget: function HS__setTarget(source, property, target) {
  439.     if (this._ds.hasArcOut(source, property)) {
  440.       var oldTarget = this._ds.GetTarget(source, property, true);
  441.       this._ds.Change(source, property, oldTarget, target);
  442.     }
  443.     else
  444.       this._ds.Assert(source, property, target, true);
  445.   },
  446.  
  447.   /**
  448.    * Remove a property of an RDF source.
  449.    *
  450.    * @param sourceURI   {string} the URI of the source
  451.    * @param propertyURI {string} the URI of the property
  452.    */
  453.   _removeValue: function HS__removeValue(sourceURI, propertyURI) {
  454.     var source = this._rdf.GetResource(sourceURI);
  455.     var property = this._rdf.GetResource(propertyURI);
  456.  
  457.     if (this._ds.hasArcOut(source, property)) {
  458.       var target = this._ds.GetTarget(source, property, true);
  459.       this._ds.Unassert(source, property, target, true);
  460.     }
  461.   },
  462.  
  463.  
  464.   //**************************************************************************//
  465.   // Utilities
  466.  
  467.   // FIXME: given that I keep copying them from JS component to JS component,
  468.   // these utilities should all be in a JavaScript module or FUEL interface.
  469.  
  470.   /**
  471.    * Get an app pref or a default value if the pref doesn't exist.
  472.    *
  473.    * @param   aPrefName
  474.    * @param   aDefaultValue
  475.    * @returns the pref's value or the default (if it is missing)
  476.    */
  477.   _getAppPref: function _getAppPref(aPrefName, aDefaultValue) {
  478.     try {
  479.       var prefBranch = Cc["@mozilla.org/preferences-service;1"].
  480.                        getService(Ci.nsIPrefBranch);
  481.       switch (prefBranch.getPrefType(aPrefName)) {
  482.         case prefBranch.PREF_STRING:
  483.           return prefBranch.getCharPref(aPrefName);
  484.  
  485.         case prefBranch.PREF_INT:
  486.           return prefBranch.getIntPref(aPrefName);
  487.  
  488.         case prefBranch.PREF_BOOL:
  489.           return prefBranch.getBoolPref(aPrefName);
  490.       }
  491.     }
  492.     catch (ex) { /* return the default value */ }
  493.     
  494.     return aDefaultValue;
  495.   },
  496.  
  497.   // Console Service
  498.   __consoleSvc: null,
  499.   get _consoleSvc() {
  500.     if (!this.__consoleSvc)
  501.       this.__consoleSvc = Cc["@mozilla.org/consoleservice;1"].
  502.                           getService(Ci.nsIConsoleService);
  503.     return this.__consoleSvc;
  504.   },
  505.  
  506.   _log: function _log(aMessage) {
  507.     if (!this._getAppPref("browser.contentHandling.log", false))
  508.       return;
  509.  
  510.     aMessage = "*** HandlerService: " + aMessage;
  511.     dump(aMessage + "\n");
  512.     this._consoleSvc.logStringMessage(aMessage);
  513.   }
  514. };
  515.  
  516.  
  517. //****************************************************************************//
  518. // More XPCOM Plumbing
  519.  
  520. function NSGetModule(compMgr, fileSpec) {
  521.   return XPCOMUtils.generateModule([HandlerService]);
  522. }
  523.